const jwt = require('jsonwebtoken');
const { PrismaClient } = require('@prisma/client');
const prisma = new PrismaClient();
const config = require('../config/env');

// 从环境变量获取JWT密钥，默认使用一个安全的密钥
const JWT_SECRET = config.JWT_SECRET || 'hello-beer-pos-secret';

// 是否启用测试模式（不需要认证）
const TEST_MODE = false; // 禁用测试模式，正常要求用户登录

/**
 * 认证中间件
 * 用于验证用户身份和授权
 */
const authMiddleware = (req, res, next) => {
  try {
    // 从请求头获取token
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return res.status(401).json({
        status: 'error',
        message: '未提供认证令牌'
      });
    }

    // 提取token
    const token = authHeader.split(' ')[1];
    
    // 验证token
    const decoded = jwt.verify(token, JWT_SECRET);
    
    // 将用户信息添加到请求对象
    req.user = decoded;
    next();
  } catch (error) {
    console.error('认证失败:', error);
    return res.status(401).json({
      status: 'error',
      message: '认证失败',
      error: error.message
    });
  }
};

/**
 * 认证中间件
 * 验证请求头中的JWT令牌
 */
const authenticate = async (req, res, next) => {
  try {
    // 获取请求头中的Authorization
    const authHeader = req.headers.authorization;
    
    // 如果没有Authorization头，返回401错误
    if (!authHeader) {
      console.log('认证失败: 未提供认证令牌');
      return res.status(401).json({
        status: 'error',
        message: '未提供认证令牌'
      });
    }
    
    // 提取令牌
    const token = authHeader.split(' ')[1];
    
    // 如果没有令牌，返回401错误
    if (!token) {
      console.log('认证失败: 未提供认证令牌');
      return res.status(401).json({
        status: 'error',
        message: '未提供认证令牌'
      });
    }
    
    // 验证令牌
    const decoded = jwt.verify(token, JWT_SECRET);
    console.log('令牌解码:', decoded);
    
    // 查询用户
    const user = await prisma.user.findUnique({
      where: { id: decoded.id },
      include: {
        role: {
          include: {
            permissions: {
              include: {
                permission: true
              }
            }
          }
        },
        department: true
      }
    });
    
    // 如果用户不存在或已禁用，返回401错误
    if (!user || !user.status) {
      console.log('认证失败: 用户不存在或已被禁用');
      return res.status(401).json({
        status: 'error',
        message: '用户不存在或已被禁用'
      });
    }
    
    // 将用户信息添加到请求对象
    req.user = {
      id: user.id,
      username: user.username,
      name: user.name,
      roleId: user.roleId,
      departmentId: user.departmentId,
      // 添加权限信息，方便后续使用
      _permissions: user.role?.permissions.map(p => p.permission.code) || []
    };
    
    console.log('认证成功:', req.user);
    
    // 继续处理请求
    next();
  } catch (error) {
    // 认证失败，返回401错误
    console.error('认证中间件错误:', error);
    return res.status(401).json({
      status: 'error',
      message: '认证失败',
      error: error.message
    });
  }
}; 

/**
 * 授权中间件
 * 验证用户是否有权限访问特定资源
 */
const authorize = (roles = []) => {
  if (typeof roles === 'string') {
    roles = [roles];
  }
  
  return (req, res, next) => {
    // 测试模式开启时，直接放行
    if (TEST_MODE) {
      console.log('测试模式: 跳过授权检查');
      return next();
    }
    
    // 检查用户是否已认证
    if (!req.user) {
      return res.status(401).json({
        status: 'error',
        message: '未认证的用户'
      });
    }
    
    // 管理员角色拥有所有权限
    if (req.user.roleId === 1) {
      return next();
    }
    
    // 这里简化处理，假设用户有权限
    // 真实场景中应该根据用户的角色和权限进行判断
    console.log(`授权检查 - 用户:${req.user.username}, 需要角色:${roles.join(',')}`);
    next();
  };
};

module.exports = {
  authMiddleware,
  authenticate,
  authorize
}; 